package com.bw.cart.server.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bw.cart.common.domain.PmsSkuInfo;
import com.bw.cart.common.domain.vo.CartItem;
import com.bw.cart.common.domain.vo.CartVo;
import com.bw.cart.server.config.RedisConstants;
import com.bw.common.redis.service.RedisService;
import com.bw.common.security.utils.SecurityUtils;
import com.bw.system.api.model.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import com.bw.cart.server.mapper.PmsCartMapper;
import com.bw.cart.common.domain.PmsCart;
import com.bw.cart.server.service.IPmsCartService;

import javax.servlet.http.HttpServletRequest;

/**
 * 购物车Service业务层处理
 * 
 * @author bw
 * @date 2024-12-27
 */
@Service
public class PmsCartServiceImpl implements IPmsCartService 
{
    @Autowired
    private PmsCartMapper pmsCartMapper;
    @Autowired
    private RedisService redisService;

    /**
     * 查询购物车
     * 
     * @param id 购物车主键
     * @return 购物车
     */
    @Override
    public PmsCart selectPmsCartById(Long id)
    {
        return pmsCartMapper.selectPmsCartById(id);
    }

    /**
     * 查询购物车列表
     * 
     * @param pmsCart 购物车
     * @return 购物车
     */
    @Override
    public List<PmsCart> selectPmsCartList(PmsCart pmsCart)
    {
        return pmsCartMapper.selectPmsCartList(pmsCart);
    }

    /**
     * 新增购物车
     * 
     * @param pmsCart 购物车
     * @return 结果
     */
    @Override
    public int insertPmsCart(PmsCart pmsCart)
    {
        return pmsCartMapper.insertPmsCart(pmsCart);
    }

    /**
     * 修改购物车
     * 
     * @param pmsCart 购物车
     * @return 结果
     */
    @Override
    public int updatePmsCart(PmsCart pmsCart)
    {
        return pmsCartMapper.updatePmsCart(pmsCart);
    }

    /**
     * 批量删除购物车
     * 
     * @param ids 需要删除的购物车主键
     * @return 结果
     */
    @Override
    public int deletePmsCartByIds(Long[] ids)
    {
        return pmsCartMapper.deletePmsCartByIds(ids);
    }

    /**
     * 删除购物车信息
     * @param id 购物车主键
     * @return 结果
     */
    @Override
    public int deletePmsCartById(Long id)
    {
        return pmsCartMapper.deletePmsCartById(id);
    }

    /**
     * 查询购物车
     *
     * @return
     */
    @Override
    public List<CartVo> selectCartList() {
//        LoginUser loginUser = SecurityUtils.getLoginUser();
//        Long userid = loginUser.getUserid();
        //从redis中取出所有的数据
        Map<String, Object> cacheMap = redisService.getCacheMap(RedisConstants.USER_CART + 1);
        JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(cacheMap));
        Set<String> keys = jsonObject.keySet();
        List<CartItem> cartItemList = new ArrayList<>();
        for (String key : keys) {
            CartItem cartItem = jsonObject.getObject(key, CartItem.class);
            cartItemList.add(cartItem);
        }
        List<CartVo> cartVos = new ArrayList<>();
        List<CartVo> cartVoList = convertToListOfCartVo(cartItemList);
        cartVoList.forEach(cartVo->{
            System.out.println(cartVo.getSellerId());
            cartVo.getCartItemList().forEach(item->{
                System.out.println(item.getNum());
            });
            cartVos.add(cartVo);
        });

        return cartVoList;
    }

    public static List<CartVo> convertToListOfCartVo(List<CartItem> cartItemList) {
        // 使用 Stream API 按 sellerId 分组
        Map<Long, List<CartItem>> groupedBySellerId = cartItemList.stream()
                .collect(Collectors.groupingBy(CartItem::getSellerId));

        // 创建 CartVo 列表
        List<CartVo> cartVoList = new ArrayList<>();

        // 遍历分组后的 Map，创建 CartVo 对象
        for (Map.Entry<Long, List<CartItem>> entry : groupedBySellerId.entrySet()) {
            Long sellerId = entry.getKey();
            List<CartItem> items = entry.getValue();

            // 假设 CartItem 中有方法 getSellerName() 可以获取 sellerName（如果没有，则需要调整逻辑）
            // 这里我们取第一个 CartItem 的 sellerName 作为该 sellerId 下的 sellerName（可能需要根据实际需求调整）
            String sellerName = items.get(0).getSellerName(); // 注意：这里可能不是最佳实践，因为可能不是所有 CartItem 的 sellerName 都相同

            // 创建 CartVo 对象并添加到列表中
            CartVo cartVo = new CartVo();
            cartVo.setSellerId(sellerId);
            cartVo.setSellerName(sellerName);
            cartVo.setCartItemList(items);

            cartVoList.add(cartVo);
        }

        return cartVoList;
    }

    @Override
    public void addCart(Long skuId) {
        //获取登录用户信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        Long userid = loginUser.getUserid();
        String userCart = RedisConstants.USER_CART + userid;

        //判断缓存中有没有数据
        if (!redisService.hasKey(userCart)){
            //调用封装方法
            PmsCart cartInfo = getInfoBySkuId(skuId);
//            判断数据库中有没有数据
            if (cartInfo == null){
                redisService.setCacheMap(userCart,null);
                // 如果都没有，则有可能出现穿透，添加一个空值，防止穿透
            }
        }
        //封装一个方法

//        获取缓存中数据
        Object cacheMapValue = redisService.getCacheMapValue(userCart,skuId.toString());
//        转换成对象
        CartItem cartItem = JSON.parseObject(JSONObject.toJSONString(cacheMapValue), CartItem.class);
//        判断购物车中有没有该商品
        if (cartItem == null){
            cartItem = createCartItem(skuId);
        }

        if (cartItem.getNum() > 200){
            throw new RuntimeException("不能超过200");
        }

        cartItem.setNum(cartItem.getNum() + 1);
        redisService.setCacheMapValue(userCart, skuId.toString(), cartItem);
    }

    @Override
    public void deleteCart(Long skuId) {
//        LoginUser loginUser = SecurityUtils.getLoginUser();
//        Long userid = loginUser.getUserid();
        String userCart = RedisConstants.USER_CART + 1;

        Object cacheMapValue = redisService.getCacheMapValue(userCart, skuId.toString());
        CartItem cartItem = JSON.parseObject(JSONObject.toJSONString(cacheMapValue), CartItem.class);

        if (cartItem != null){
            redisService.deleteCacheMapValue(userCart, skuId.toString());
        }

    }

    @Override
    public void placeAnOrder(CartItem cartItem) {

    }

    protected PmsCart getInfoBySkuId(Long skuId){
        PmsCart pmsCar = pmsCartMapper.selectCartItemBySKuId(skuId);
        return pmsCar;
    }

    protected CartItem createCartItem(Long skuId){

        CartItem cartItem = new CartItem();
        PmsSkuInfo pmsSkuInfo = pmsCartMapper.selectSkuInfoBySkuId(skuId);
        cartItem.setSkuId(skuId);
        cartItem.setSellerId(pmsSkuInfo.getSellerId());
        cartItem.setNum(Long.valueOf(0));
        cartItem.setChecked(false);
        cartItem.setPrice(pmsSkuInfo.getPrice());
        cartItem.setSkuName(pmsSkuInfo.getSkuName());
        cartItem.setSkuImg(pmsSkuInfo.getSkuDefaultImg());
        cartItem.setSubTitle(pmsSkuInfo.getSkuSubtitle());
        cartItem.setSkuTitle(pmsSkuInfo.getSkuTitle());
        cartItem.setSellerName(pmsSkuInfo.getSellerName());

        return cartItem;
    }

    @Scheduled(cron = "* 0/20 * * * ?")
    public void deleteCartAll(){
//        LoginUser loginUser = SecurityUtils.getLoginUser();
//        Long userid = loginUser.getUserid();
        String userCart = RedisConstants.USER_CART + 1;

        pmsCartMapper.deleteCartItemAll();
        Map<String, Object> cacheMap = redisService.getCacheMap(userCart);

        if (cacheMap != null){
            cacheMap.forEach((k,v) -> {
                Object cacheMapValue = redisService.getCacheMapValue(userCart, k);
                CartItem cartItem = JSON.parseObject(JSONObject.toJSONString(cacheMapValue), CartItem.class);
                CartItem cartItem1 = new CartItem();
                cartItem1.setSkuId(cartItem.getSkuId());
                cartItem1.setNum(cartItem.getNum());
                cartItem1.setChecked(cartItem.getChecked());
                cartItem1.setUserId(1L);
                pmsCartMapper.insertCartItemAll(cartItem1);
            });
        }
    }

}
